home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 2 / Atari Mega Archive CD - Volume 2.iso / minix / up1510b.tgz / up1510b / src / commands / kermit / ckcfns.c < prev    next >
C/C++ Source or Header  |  1990-07-19  |  33KB  |  1,040 lines
  1. char *fnsv = "C-Kermit functions, 4E(053) 14 Sep 87";
  2.  
  3. /*  C K C F N S  --  System-independent Kermit protocol support functions.  */
  4.  
  5. /*  ...Part 1 (others moved to ckcfn2 to make this module small enough) */
  6.  
  7. /*
  8.  4E includes support for Data General systems from Phil Julian of SAS 
  9.  Institute, and Megamax native Macintosh C compiler support from
  10.  Jim Noble of Planning Research Corporation.
  11. */ 
  12. /*
  13.  Author: Frank da Cruz (SY.FDC@CU20B),
  14.  Columbia University Center for Computing Activities, January 1985.
  15.  Copyright (C) 1985, Trustees of Columbia University in the City of New York.
  16.  Permission is granted to any individual or institution to use, copy, or
  17.  redistribute this software so long as it is not sold for profit, provided this
  18.  copyright notice is retained. 
  19. */
  20. /*
  21.  System-dependent primitives defined in:
  22.  
  23.    ck?tio.c -- terminal i/o
  24.    cx?fio.c -- file i/o, directory structure
  25. */
  26. #include "ckcsym.h"            /* Need this for Mac */
  27. #include "ckcker.h"            /* Symbol definitions for Kermit */
  28. #include "ckcdeb.h"            /* Debug formats, typedefs, etc. */
  29.  
  30. #ifndef NULL
  31. #define NULL 0
  32. #endif
  33.  
  34. /* Externals from ckcmai.c */
  35. extern int spsiz, rpsiz, timint, rtimo, npad, ebq, ebqflg, rpt, rptq,
  36.  rptflg, capas, keep;
  37. extern int pktnum, prvpkt, sndtyp, bctr, bctu, fmask,
  38.  size, osize, maxsize, spktl, nfils, stdouf, warn, timef, spsizf;
  39. extern int parity, speed, turn, turnch, 
  40.  delay, displa, pktlog, tralog, seslog, xflg, mypadn;
  41. extern long filcnt, ffc, flci, flco, tlci, tlco, tfc, fsize;
  42. extern int tsecs;
  43. extern int deblog, hcflg, binary, savmod, fncnv, local, server, cxseen, czseen;
  44. extern int rq, rqf, sq, wsize, urpsiz, rln;
  45. extern int atcapr, atcapb, atcapu;
  46. extern int lpcapr, lpcapb, lpcapu;
  47. extern int swcapr, swcapb, swcapu;
  48. extern CHAR padch, mypadc, eol, seol, ctlq, myctlq, sstate;
  49. extern CHAR filnam[], sndpkt[], recpkt[], data[], srvcmd[], stchr, mystch;
  50. extern char *cmarg, *cmarg2, *hlptxt, **cmlist;
  51. extern CHAR *srvptr;
  52. extern char *rdatap;
  53. long zchki();
  54. char *strcpy();
  55. CHAR *rpar();
  56.  
  57. /* Variables local to this module */
  58.  
  59. static char *memptr;            /* Pointer for memory strings */
  60.  
  61. static char cmdstr[100];        /* Unix system command string */
  62.  
  63. static int  sndsrc;            /* Flag for where to send from: */
  64.                     /* -1: name in cmdata */
  65.                     /*  0: stdin          */
  66.                     /* >0: list in cmlist */
  67.  
  68. static int  memstr,            /* Flag for input from memory string */
  69.     first;                /* Flag for first char from input */
  70. static CHAR t,                /* Current character */
  71.     next;                /* Next character */
  72. #ifdef datageneral
  73. extern int quiet;
  74. #endif
  75.  
  76. /*  E N C S T R  --  Encode a string from memory. */
  77.  
  78. /*  Call this instead of getpkt() if source is a string, rather than a file. */
  79.  
  80. encstr(s) char* s; {
  81.     int m; char *p;
  82.  
  83.     m = memstr; p = memptr;        /* Save these. */
  84.  
  85.     memptr = s;                /* Point to the string. */
  86.     memstr = 1;                /* Flag memory string as source. */
  87.     first = 1;                /* Initialize character lookahead. */
  88.     getpkt(spsiz-bctu-3);        /* Fill a packet from the string. */
  89.     memstr = m;                /* Restore memory string flag */
  90.     memptr = p;                /* and pointer */
  91.     first = 1;                /* Put this back as we found it. */
  92. }
  93.  
  94. /* E N C O D E - Kermit packet encoding procedure */
  95.  
  96. encode(a) CHAR a; {            /* The current character */
  97.     int a7;                /* Low order 7 bits of character */
  98.     int b8;                /* 8th bit of character */
  99.  
  100.     if (rptflg)    {                   /* Repeat processing? */
  101.         if (a == next && (first == 0)) { /* Got a run... */
  102.         if (++rpt < 94)        /* Below max, just count */
  103.                 return;
  104.         else if (rpt == 94) {    /* Reached max, must dump */
  105.                 data[size++] = rptq;
  106.                 data[size++] = tochar(rpt);
  107.                 rpt = 0;
  108.         }
  109.         } else if (rpt == 1) {        /* Run broken, only 2? */
  110.             rpt = 0;            /* Yes, reset repeat flag & count. */
  111.         encode(a);            /* Do the character twice. */
  112.         if (size <= maxsize) osize = size;
  113.         rpt = 0;
  114.         encode(a);
  115.         return;
  116.     } else if (rpt > 1) {        /* More than two */
  117.             data[size++] = rptq;    /* Insert the repeat prefix */
  118.             data[size++] = tochar(++rpt); /* and count. */
  119.             rpt = 0;            /* Reset repeat counter. */
  120.         }
  121.     }
  122.     a7 = a & 0177;            /* Isolate ASCII part */
  123.     b8 = a & 0200;            /* and 8th (parity) bit. */
  124.  
  125.     if (ebqflg && b8) {            /* Do 8th bit prefix if necessary. */
  126.         data[size++] = ebq;
  127.         a = a7;
  128.     }
  129.     if ((a7 < SP) || (a7==DEL))    {    /* Do control prefix if necessary */
  130.         data[size++] = myctlq;
  131.     a = ctl(a);
  132.     }
  133.     if (a7 == myctlq)            /* Prefix the control prefix */
  134.         data[size++] = myctlq;
  135.  
  136.     if ((rptflg) && (a7 == rptq))    /* If it's the repeat prefix, */
  137.         data[size++] = myctlq;        /* quote it if doing repeat counts. */
  138.  
  139.     if ((ebqflg) && (a7 == ebq))    /* Prefix the 8th bit prefix */
  140.         data[size++] = myctlq;        /* if doing 8th-bit prefixes */
  141.  
  142.     data[size++] = a;            /* Finally, insert the character */
  143.     data[size] = '\0';            /* itself, and mark the end. */
  144. }
  145.  
  146. /* D E C O D E  --  Kermit packet decoding procedure */
  147.  
  148. /* Call with string to be decoded and an output function. */
  149. /* Returns 0 on success, -1 on failure (e.g. disk full).  */
  150.  
  151. decode(buf,fn) CHAR *buf; int (*fn)(); {
  152.     unsigned int a, a7, b8;        /* Low order 7 bits, and the 8th bit */
  153.  
  154.     rpt = 0;                /* Initialize repeat count. */
  155.  
  156.     while ((a = *buf++) != '\0') {
  157.     if (rptflg) {            /* Repeat processing? */
  158.         if (a == rptq) {        /* Yes, got a repeat prefix? */
  159.         rpt = xunchar(*buf++);    /* Yes, get the repeat count, */
  160.         a = *buf++;        /* and get the prefixed character. */
  161.         }
  162.     }
  163.     b8 = 0;                /* Check high order "8th" bit */
  164.     if (ebqflg) {            /* 8th-bit prefixing? */
  165.         if (a == ebq) {        /* Yes, got an 8th-bit prefix? */
  166.         b8 = 0200;        /* Yes, remember this, */
  167.         a = *buf++;        /* and get the prefixed character. */
  168.         }
  169.     }
  170.     if (a == ctlq) {        /* If control prefix, */
  171.         a  = *buf++;        /* get its operand. */
  172.         a7 = a & 0177;        /* Only look at low 7 bits. */
  173.         if ((a7 >= 0100 && a7 <= 0137) || a7 == '?') /* Uncontrollify */
  174.         a = ctl(a);            /* if in control range. */
  175.     }
  176.     a |= b8;            /* OR in the 8th bit */
  177.     if (rpt == 0) rpt = 1;        /* If no repeats, then one */
  178. #ifdef NLCHAR
  179.     if (!binary) {            /* If in text mode, */
  180.         if (a == CR) continue;    /* discard carriage returns, */
  181.             if (a == LF) a = NLCHAR;     /* convert LF to system's newline. */
  182.         }
  183. #endif
  184.     for (; rpt > 0; rpt--) {    /* Output the char RPT times */
  185.         if ((*fn)(a) < 0) return(-1); /* Send it to the output function. */
  186.         ffc++, tfc++;        /* Count the character */
  187.     }
  188.     }
  189.     return(0);
  190. }
  191.  
  192.  
  193. /*  Output functions passed to 'decode':  */
  194.  
  195. putsrv(c) char c; {     /*  Put character in server command buffer  */
  196.     *srvptr++ = c;
  197.     *srvptr = '\0';    /* Make sure buffer is null-terminated */
  198.     return(0);
  199. }
  200.  
  201. puttrm(c) char c; {     /*  Output character to console.  */
  202.     conoc(c);
  203.     return(0);
  204. }
  205.  
  206. putfil(c) char c; {            /*  Output char to file. */
  207.     if (zchout(ZOFILE, c & fmask) < 0) {
  208.     czseen = 1;               /* If write error... */
  209.     debug(F101,"putfil zchout write error, setting czseen","",1);
  210.     return(-1);
  211.     }
  212.     return(0);
  213. }
  214.  
  215. /*  G E T P K T -- Fill a packet data field  */
  216.  
  217. /*
  218.  Gets characters from the current source -- file or memory string.
  219.  Encodes the data into the packet, filling the packet optimally.
  220.  Set first = 1 when calling for the first time on a given input stream
  221.  (string or file).
  222.  
  223.  Uses global variables:
  224.  t     -- current character.
  225.  first -- flag: 1 to start up, 0 for input in progress, -1 for EOF.
  226.  next  -- next character.
  227.  data  -- the packet data buffer.
  228.  size  -- number of characters in the data buffer.
  229.  
  230. Returns the size as value of the function, and also sets global size,
  231. and fills (and null-terminates) the global data array.  Returns 0 upon eof.
  232. */
  233.  
  234. getpkt(bufmax) int bufmax; {        /* Fill one packet buffer */
  235.     int i, x;                /* Loop index. */
  236.     
  237.     static char leftover[6] = { '\0', '\0', '\0', '\0', '\0', '\0' };
  238.  
  239.     if (first == 1) {        /* If first time thru...  */
  240.     first = 0;        /* remember, */
  241.     *leftover = '\0';       /* discard any interrupted leftovers, */
  242.     x = getchx(&t);        /* get first character of file into t, */
  243.     if (x == 0) {            /* watching out for nul